package com.sky.zuor;

import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
import lombok.Data;
import okhttp3.*;

import java.io.IOException;
import java.util.List;


public class zhuoruiTrade {
    public static final String base = "https://openapi8.zr66.com";




    // ------------------ 下单接口 ------------------
    public EntrustResponse entrustOrder( EntrustEnterVO requestVO, String token) throws IOException {
        Gson gson = new GsonBuilder().create();

        // 创建请求
        Request request = new Request.Builder()
                .url(base + "/trade/entrust_enter") // 替换为实际的服务器地址
                .addHeader("token", token)
                .post(RequestBody.create(gson.toJson(requestVO), MediaType.parse("application/json")))
                .build();

        OkHttpClient client = new OkHttpClient();
        // 发送请求并处理响应
        try (Response response = client.newCall(request).execute()) {
            if (!response.isSuccessful()) {
                throw new IOException("Unexpected code " + response);
            }

            // 处理响应
            String responseData = response.body().string();
            System.out.println("Response: " + responseData);

            // 将响应解析为 EntrustResponse 对象
            return gson.fromJson(responseData, EntrustResponse.class);
        }
    }
    // 请求参数类
    @Data
    public static class EntrustEnterVO {
        private String ts; // 交易市场
        private String code; // 证券代码
        private String entrustProp; // 委托属性
        private double entrustPrice; // 委托价格
        private int entrustAmount; // 委托数量
        private String entrustBs; // 买卖方向
        private String allowPrePost; // 是否允许盘前盘后单
        private Integer apStatus; // 暗盘状态

        // Getters and Setters
    }
    // 响应类
    @Data
    public class EntrustResponse {
        private String code; // 错误码
        private String msg; // 异常描述
        private EntrustResponseData data; // 返回的数据（可以根据需要进一步解析）

        // Getters and Setters
    }
    @Data
    public  class EntrustResponseData {
        private Integer entrustNo; // 委托编号
        private String entrustProp; // 委托属性
        private String orderNo; // 订单号
        private String orderTxnReference; // 记录号
        private String riskTypeMsg; // 风险类型提示语

        // Getters 和 Setters
    }



    // ------------------ 改单接口 ------------------
    public EntrustModifyResponse modifyOrder(EntrustModifyVO requestVO, String token) throws IOException {
        Gson gson = new GsonBuilder().create();

        // 创建请求
        Request request = new Request.Builder()
                .url(base + "/trade/entrust_modify") // 替换为实际的服务器地址
                .addHeader("token", token)
                .post(RequestBody.create(gson.toJson(requestVO), MediaType.parse("application/json")))
                .build();
        OkHttpClient client = new OkHttpClient();
        // 发送请求并处理响应
        try (Response response = client.newCall(request).execute()) {
            if (!response.isSuccessful()) {
                throw new IOException("Unexpected code " + response);
            }

            // 处理响应
            String responseData = response.body().string();
            System.out.println("Response: " + responseData);

            // 将响应解析为 EntrustModifyResponse 对象
            return gson.fromJson(responseData, EntrustModifyResponse.class);
        }
    }

    // 请求参数类
    @Data
    public static class EntrustModifyVO {
        private String orderTxnReference; // 订单记录号
        private double entrustPrice; // 委托价格
        private int entrustAmount; // 委托数量
        private String entrustProp; // 委托属性
        private String remark; // 备注

        // Getters and Setters
    }

    // 响应类
    @Data
    public class EntrustModifyResponse {
        private String code; // 错误码
        private String msg; // 异常描述
        private EntrustModifyResponseData data; // 返回的数据（可以根据需要进一步解析）


        // Getters and Setters
    }
    @Data
    public class EntrustModifyResponseData{
        private String entrustStatus; // 委托状态
        private String orderNo; // 订单号
        private String riskTypeMsg; // 风险类型提示语
    }



    // ------------------ 撤单接口 ------------------
    public EntrustWithdrawResponse withdrawOrder(EntrustWithdrawVO requestVO, String token) throws IOException {
        Gson gson = new GsonBuilder().create();

        // 创建请求
        Request request = new Request.Builder()
                .url(base + "/trade/entrust_withdraw") // 替换为实际的服务器地址
                .addHeader("token", token)
                .post(RequestBody.create(gson.toJson(requestVO), MediaType.parse("application/json")))
                .build();
        OkHttpClient client = new OkHttpClient();
        // 发送请求并处理响应
        try (Response response = client.newCall(request).execute()) {
            if (!response.isSuccessful()) {
                throw new IOException("Unexpected code " + response);
            }

            // 处理响应
            String responseData = response.body().string();
            System.out.println("Response: " + responseData);

            // 将响应解析为 EntrustWithdrawResponse 对象
            return gson.fromJson(responseData, EntrustWithdrawResponse.class);
        }
    }

    // 请求参数类
    @Data
    public static class EntrustWithdrawVO {
        private String orderTxnReference; // 订单记录号
        private String remark; // 备注（可选）

        // Getters and Setters
    }

    // 响应类
    @Data
    public class EntrustWithdrawResponse {
        private String code; // 错误码
        private String msg; // 异常描述

        // Getters and Setters
    }










    // ------------------ 查询历史订单接口 ------------------
    public AllEntrustResponse getAllEntrust(AllEntrustVO requestVO, String token) throws IOException {
        Gson gson = new GsonBuilder().create();

        // 创建请求
        Request request = new Request.Builder()
                .url(base + "/trade/get_all_entrust") // 替换为实际的服务器地址
                .addHeader("token", token)
                .post(RequestBody.create(gson.toJson(requestVO), MediaType.parse("application/json")))
                .build();
        OkHttpClient client = new OkHttpClient();
        // 发送请求并处理响应
        try (Response response = client.newCall(request).execute()) {
            if (!response.isSuccessful()) {
                throw new IOException("Unexpected code " + response);
            }

            // 处理响应
            String responseData = response.body().string();
            System.out.println("Response: " + responseData);

            // 将响应解析为 AllEntrustResponse 对象
            return gson.fromJson(responseData, AllEntrustResponse.class);
        }
    }

    // 请求参数类
    @Data
    public static class AllEntrustVO {
        private String startDate; // 开始日期,格式：时间戳
        private String endDate;   // 结束日期,格式：时间戳
        private String orderTxnReference; // 订单记录号（可选）

        // Getters and Setters
    }

    // 响应类
    @Data
    public class AllEntrustResponse {
        private String code; // 错误码
        private String msg;  // 异常描述
        private List<EntrustRecord> data; // 历史订单记录

        // Getters and Setters
    }

    // 历史订单记录类
    @Data
    public static class EntrustRecord {
        private double businessAmount; // 成交数量
        private String code; // 证券代码
        private double entrustAmount; // 委托数量
        private String entrustBs; // 买卖方向
        private String entrustNo; // 委托编号
        private double entrustPrice; // 委托价格
        private String entrustProp; // 委托属性
        private String entrustStatus; // 委托状态
        private String entrustTime; // 委托时间
        private int market; // 股票市场
        private String name; // 证券名称
        private String orderNo; // 订单号
        private String orderTxnReference; // 记录号
        private String sessionType; // 交易阶段
        private String ts; // 交易市场
        private int type; // 证券类型

        // Getters and Setters
    }






    // ------------------ 查询成交明细 ------------------
    public EntrustDetailResponse getEntrustDetail(EntrustDetailVO requestVO, String token) throws IOException
    {
        Gson gson = new GsonBuilder().create();

        // 创建请求
        Request request = new Request.Builder().url(base + "/trade/get_entrust_detail") // 替换为实际的服务器地址
                .addHeader("token", token)
                .post(RequestBody.create(gson.toJson(requestVO), MediaType.parse("application/json")))
                .build();
        OkHttpClient client = new OkHttpClient();
        // 发送请求并处理响应
        try (Response response = client.newCall(request).execute())
        {
            if (!response.isSuccessful())
            {
                throw new IOException("Unexpected code " + response);
            }

            // 处理响应
            String responseData = response.body().string();
            System.out.println("Response: " + responseData);

            // 将响应解析为 EntrustDetailResponse 对象
            return gson.fromJson(responseData, EntrustDetailResponse.class);
        }
    }

    // 请求参数类
    @Data
    public static class EntrustDetailVO
    {
        private String orderTxnReference; // 订单记录号
        private String entrustTime; // 委托时间（时间戳）

        // Getters and Setters
    }

    // 响应类
    @Data
    public class EntrustDetailResponse
    {
        private String code; // 错误码
        private String msg;  // 异常描述
        private BargainDetail data; // 成交明细列表

        // Getters and Setters
    }

    // 响应数据类
    @Data
    public static class BargainDetail
    {
        private List<Bargain> bargainList; //成交明细
        private double businessAmount; // 成交数量
        private String code; // 证券代码
        private double entrustAmount; // 委托数量
        private String entrustBs; // 买卖方向
        private String entrustNo; // 委托编号
        private double entrustPrice; // 委托价格
        private String entrustProp; // 委托属性
        private String entrustStatus; // 委托状态
        private String entrustTime; // 委托时间
        private int market; // 股票市场
        private String name; // 证券名称
        private String orderNo; // 订单号
        private String orderTxnReference; // 记录号
        private String sessionType; // 交易阶段
        private String ts; // 交易市场
        private int type; // 证券类型

        // Getters and Setters
    }

    //成交明细
    @Data
    public class Bargain
    {
        private double businessAmount; // 成交数量
        private double businessBalance; // 成交金额
        private double businessPrice; // 成交价格
        private String businessTime; // 成交时间
    }


    // ------------------ 查询最大可买可卖 ------------------
    public StockAmountResponse getStockAmount(GetStockAmountVO requestVO, String token) throws IOException
    {
        Gson gson = new GsonBuilder().create();

        // 创建请求
        Request request = new Request.Builder().url(base + "/trade/get_stock_amount") // 替换为实际的服务器地址
                .addHeader("token", token)
                .post(RequestBody.create(gson.toJson(requestVO), MediaType.parse("application/json")))
                .build();

        OkHttpClient client = new OkHttpClient();
        // 发送请求并处理响应
        try (Response response = client.newCall(request).execute())
        {
            if (!response.isSuccessful())
            {
                throw new IOException("Unexpected code " + response);
            }

            // 处理响应
            String responseData = response.body().string();
            System.out.println("Response: " + responseData);

            // 将响应解析为 StockAmountResponse 对象
            return gson.fromJson(responseData, StockAmountResponse.class);
        }
    }

    // 请求参数类
    @Data
    public static class GetStockAmountVO
    {
        private String ts; // 股票市场
        private String code; // 股票代码
        private String entrustProp; // 委托属性
        private Double entrustPrice; // 委托价格（可选）
        private Integer apStatus; // 暗盘状态（可选）

        // Getters and Setters
    }

    // 响应类
    @Data
    public class StockAmountResponse
    {
        private String code; // 错误码
        private String msg;  // 异常描述
        private StockAmountData data; // 最大可买可卖数据

        // Getters and Setters
    }

    // 最大可买可卖数据类
    @Data
    public static class StockAmountData
    {
        private double availBuyAmount; // 现金可买数量（仅孖展账户）
        private double enableBuyAmount; // 可买数量
        private double enableBuyAmountM; // 融资可买数量（仅孖展账户）
        private double enableSellAmount; // 可卖数量

        // Getters and Setters
    }


    // ------------------ 查询当日订单 ------------------
    public static TodayEntrustResponse getTodayEntrust(String token) throws IOException
    {
        Gson gson = new GsonBuilder().create();

        // 创建请求
        Request request = new Request.Builder().url(base + "/trade/get_today_entrust") // 替换为实际的服务器地址
                .addHeader("token", token).post(RequestBody.create("{}", MediaType.parse("application/json"))) // 空请求体
                .build();

        OkHttpClient client = new OkHttpClient();
        // 发送请求并处理响应
        try (Response response = client.newCall(request).execute())
        {
            if (!response.isSuccessful())
            {
                throw new IOException("Unexpected code " + response);
            }

            // 处理响应
            String responseData = response.body().string();
            System.out.println("Response: " + responseData);

            // 将响应解析为 TodayEntrustResponse 对象
            return gson.fromJson(responseData, TodayEntrustResponse.class);
        }
    }


    // 响应类
    @Data
    public class TodayEntrustResponse
    {
        private String code; // 错误码
        private String msg;  // 异常描述
        private List<TodayEntrustData> data; // 当日订单数据

        // Getters and Setters
    }

    // 当日订单数据类
    @Data
    public static class TodayEntrustData
    {
        private String allowPrePost; // 是否允许盘前盘后单
        private double businessAmount; // 成交数量
        private String code; // 证券代码
        private double entrustAmount; // 委托数量
        private String entrustBs; // 买卖方向
        private String entrustNo; // 委托编号
        private double entrustPrice; // 委托价格
        private String entrustProp; // 委托属性
        private String entrustStatus; // 委托状态
        private String entrustTime; // 委托时间
        private int market; // 股票市场
        private String name; // 证券中文名称
        private String opRemark; // 操作备注
        private String orderNo; // 订单号
        private String orderTxnReference; // 记录号
        private String remark; // 备注
        private String sessionType; // 交易阶段
        private String ts; // 交易市场
        private int type; // 证券类型

        // Getters and Setters
    }


    // ------------------ 智能订单撤单 ------------------

    public CancelIntelligentOrderResponse cancelIntelligentOrder(String id, String token) throws IOException
    {
        Gson gson = new GsonBuilder().create();

        // 创建请求参数
        SingleRequestVO requestVO = new SingleRequestVO();
        requestVO.setId(id);

        // 创建请求
        Request request = new Request.Builder().url(base + "/trade/intelligent_order/cancel") // 替换为实际的服务器地址
                .addHeader("token", token)
                .post(RequestBody.create(gson.toJson(requestVO), MediaType.parse("application/json")))
                .build();

        OkHttpClient client = new OkHttpClient();
        // 发送请求并处理响应
        try (Response response = client.newCall(request).execute())
        {
            if (!response.isSuccessful())
            {
                throw new IOException("Unexpected code " + response);
            }

            // 处理响应
            String responseData = response.body().string();
            System.out.println("Response: " + responseData);

            // 将响应解析为 CancelIntelligentOrderResponse 对象
            return gson.fromJson(responseData, CancelIntelligentOrderResponse.class);
        }
    }

    // 请求参数类
    @Data
    public static class SingleRequestVO
    {
        private String id; // 智能单Id
    }

    // 响应类
    @Data
    public class CancelIntelligentOrderResponse
    {
        private String code; // 错误码
        private String msg;  // 异常描述
    }


    // ------------------ 查询定价交易 ------------------

    public FixedPriceOrderResponse queryFixedPriceOrders(FixedPriceOrderQueryVO queryVO, String token) throws IOException
    {
        Gson gson = new GsonBuilder().create();

        // 创建请求
        Request request = new Request.Builder().url(base + "/trade/intelligent_order/fixed_price/list") // 替换为实际的服务器地址
                .addHeader("token", token)
                .post(RequestBody.create(gson.toJson(queryVO), MediaType.parse("application/json")))
                .build();

        OkHttpClient client = new OkHttpClient();
        // 发送请求并处理响应
        try (Response response = client.newCall(request).execute())
        {
            if (!response.isSuccessful())
            {
                throw new IOException("Unexpected code " + response);
            }

            // 处理响应
            String responseData = response.body().string();
            System.out.println("Response: " + responseData);

            // 将响应解析为 FixedPriceOrderResponse 对象
            return gson.fromJson(responseData, FixedPriceOrderResponse.class);
        }
    }

    // 请求参数类
    @Data
    //是否必须 true
    public static class FixedPriceOrderQueryVO
    {
        private Integer currentPage; // 当前页
        private Integer offset; // 偏移量
        private Integer pageSize; // 每页数量
        private String startTime; // 开始时间 是否必须 true
        private String endTime; // 结束时间 是否必须 true
        private Integer market; // 交易市场
        private String code; // 股票代码
        private Integer triggerStatus; // 状态
        private String marketCurrentTime; // 对应的市场当前时间

        // Getters and Setters
    }

    // 响应类
    @Data
    public class FixedPriceOrderResponse
    {
        private String code; // 错误码
        private String msg;  // 异常描述
        private FixedPriceOrderData data; // 委托信息列表


        // Getters and Setters
    }

    // 委托信息类
    @Data
    public class FixedPriceOrderData
    {

        private List<FixedPriceOrderDataList> list;
        private Integer total; // 总数量
        private Integer pageSize; // 每页数量
        private Integer currentPage; // 当前页数
        // Getters and Setters
    }


    @Data
    public class FixedPriceOrderDataList
    {
        private Integer allowPrePost; // 是否允许盘前盘后单
        private Boolean clearFlag; // 清仓标识
        private String clearTime; // 清仓时间
        private String code; // 证券代码
        private Number costPrice; // 成本价
        private String createTime; // 创建时间
        private String failCause; // 失败原因
        private String fundAccount; // 资金账号
        private HsOrder hsOrder; // 委托订单信息
        private String id; // 智能单id
        private List<IntelligentCondition> intelligentCondition; // 智能单条件
        private Integer intelligentType; // 智能单类型
        private Integer market; // 股票市场 1-港股，2-美股，3-沪深
        private String name; // 证券名称
        private double number; // 数量
        private Integer triggerStatus; // 触发状态(0：未触发，1：已触发，2：已过期，3：已撤销)
        private String triggerTime; // 触发时间
        private String ts; // 交易市场(SZ-深圳， SH-上海， HK-香港， US-美国)
        private Integer type; // 证券类型
        private String userId; // 用户id
        private String validityTime; // 有效期
    }

    // 委托订单信息类
    @Data
    public class HsOrder
    {
        private Number businessAmount; // 成交数量
        private String code; // 证券代码
        private Number entrustAmount; // 委托数量
        private String entrustBs; // 买卖方向
        private String entrustNo; // 委托编号
        private Number entrustPrice; // 委托价格
        private String entrustProp; // 委托属性
        private String entrustStatus; // 委托状态
        private String entrustTime; // 委托时间
        private Integer market; // 股票市场
        private String name; // 证券名称
        private String orderNo; // 订单号
        private String orderTxnReference; // 记录号
        private String sessionType; // 交易阶段
        private String ts; // 交易市场
        private Integer type; // 证券类型
        // 其他字段...

        // Getters and Setters
    }

    @Data
    public class IntelligentCondition
    {
        private Integer priceType; // 买入价格：0最新价1买一2卖一3指定价格4买五5卖五6买十7卖十8市价单
        private Double triggerPrice; //触发价格
        private Integer triggerType; //触发类型(0：价格，1：百分比)
        private Double trustCount; // 委托数量
        private Double trustPrice; // 委托价格
        private Integer trustType; // 委托类型 1-买入 2-卖出
        private Integer upDown; // 涨跌方向(1：涨至，0：跌至，2：平/定时单)
    }


    // ------------------ 定价交易下单 ------------------
    public FixedPriceSubmitResponse submitFixedPriceOrder(FixedPriceSubmitVO submitVO,   String token) throws IOException {
        Gson gson = new GsonBuilder().create();

        // 创建请求
        Request request = new Request.Builder()
                .url(base + "/trade/intelligent_order/fixed_price/submit") // 替换为实际的服务器地址
                .addHeader("token", token)
                .post(RequestBody.create(gson.toJson(submitVO), MediaType.parse("application/json")))
                .build();

        OkHttpClient client = new OkHttpClient();
        // 发送请求并处理响应
        try (Response response = client.newCall(request).execute()) {
            if (!response.isSuccessful()) {
                throw new IOException("Unexpected code " + response);
            }

            // 处理响应
            String responseData = response.body().string();
            System.out.println("Response: " + responseData);

            // 将响应解析为 FixedPriceSubmitResponse 对象
            return gson.fromJson(responseData, FixedPriceSubmitResponse.class);
        }
    }


    // 请求参数类
    @Data
    public static class FixedPriceSubmitVO {
        private Integer market; // 交易市场
        private String ts; // 股票市场
        private String code; // 股票代码
        private String validityTime; // 到期时间，时间戳格式
        private Integer allowPrePost; // 是否允许盘前盘后单
        private Integer upDown; // 涨跌方向
        private Integer triggerType; // 触发类型
        private Number triggerPrice; // 触发价格
        private Integer trustType; // 委托类型
        private Integer priceType; // 委托价格类型
        private Number trustPrice; // 委托价格
        private Number trustCount; // 委托数量

        // Getters and Setters
    }

    // 响应类
    @Data
    public class FixedPriceSubmitResponse {
        private String code; // 错误码
        private String msg;  // 异常描述
        private String data; // 智能单id

        // Getters and Setters
    }


    // ------------------ 定价交易改单 ------------------
    public FixedPriceUpdateResponse updateFixedPriceOrder(FixedPriceUpdateVO updateVO,   String token) throws IOException {
        Gson gson = new GsonBuilder().create();

        // 创建请求
        Request request = new Request.Builder()
                .url(base + "/trade/intelligent_order/fixed_price/update") // 替换为实际的服务器地址
                .addHeader("token", token)
                .post(RequestBody.create(gson.toJson(updateVO), MediaType.parse("application/json")))
                .build();
        OkHttpClient client = new OkHttpClient();
        // 发送请求并处理响应
        try (Response response = client.newCall(request).execute()) {
            if (!response.isSuccessful()) {
                throw new IOException("Unexpected code " + response);
            }

            // 处理响应
            String responseData = response.body().string();
            System.out.println("Response: " + responseData);

            // 将响应解析为 FixedPriceUpdateResponse 对象
            return gson.fromJson(responseData, FixedPriceUpdateResponse.class);
        }
    }

    // 请求参数类
    @Data
    public static class FixedPriceUpdateVO {
        private String id; // id
        private Integer market; // 交易市场
        private String ts; // 股票市场
        private String code; // 股票代码
        private String validityTime; // 到期时间，时间戳格式
        private Integer allowPrePost; // 是否允许盘前盘后单
        private Integer upDown; // 涨跌方向
        private Integer triggerType; // 触发类型
        private Number triggerPrice; // 触发价格
        private Integer trustType; // 委托类型
        private Integer priceType; // 委托价格类型
        private Number trustPrice; // 委托价格
        private Number trustCount; // 委托数量

        // Getters and Setters
    }

    // 响应类
    @Data
    public class FixedPriceUpdateResponse {
        private String code; // 错误码
        private String msg;  // 异常描述

        // Getters and Setters
    }

    // ------------------ 查询止盈止损交易 ------------------       查询止盈止损交易接口的vo和结果类  跟查询定价交易的字段一样
    public FixedPriceOrderResponse queryProfitLossOrders(ProfitLossOrderQueryVO queryVO, String token) throws IOException
    {
        Gson gson = new GsonBuilder().create();

        // 创建请求
        Request request = new Request.Builder().url(base + "/trade/intelligent_order/profit_loss/list") // 替换为实际的服务器地址
                .addHeader("token", token)
                .post(RequestBody.create(gson.toJson(queryVO), MediaType.parse("application/json")))
                .build();

        OkHttpClient client = new OkHttpClient();
        // 发送请求并处理响应
        try (Response response = client.newCall(request).execute())
        {
            if (!response.isSuccessful())
            {
                throw new IOException("Unexpected code " + response);
            }

            // 处理响应
            String responseData = response.body().string();
            System.out.println("Response: " + responseData);

            // 将响应解析为 FixedPriceOrderResponse 对象
            return gson.fromJson(responseData, FixedPriceOrderResponse.class);
        }
    }

    @Data
    public static class ProfitLossOrderQueryVO
    {
        private Integer currentPage; // 当前页
        private Integer offset; // 偏移量
        private Integer pageSize; // 每页数量
        private String startTime; // 开始时间 是否必须 true
        private String endTime; // 结束时间 是否必须 true
        private Integer market; // 交易市场
        private String code; // 股票代码
        private Integer triggerStatus; // 状态
        private String marketCurrentTime; // 对应的市场当前时间

        // Getters and Setters
    }

    // ------------------ 止盈止损交易下单 ------------------
    public ProfitLossSubmitResponse submitProfitLossOrder(ProfitLossSubmitVO submitVO,  String token) throws IOException {
        Gson gson = new GsonBuilder().create();

        // 创建请求
        Request request = new Request.Builder()
                .url(base + "/trade/intelligent_order/profit_loss/submit") // 替换为实际的服务器地址
                .addHeader("token", token)
                .post(RequestBody.create(gson.toJson(submitVO), MediaType.parse("application/json")))
                .build();
        OkHttpClient client = new OkHttpClient();
        // 发送请求并处理响应
        try (Response response = client.newCall(request).execute()) {
            if (!response.isSuccessful()) {
                throw new IOException("Unexpected code " + response);
            }

            // 处理响应
            String responseData = response.body().string();
            System.out.println("Response: " + responseData);

            // 将响应解析为 ProfitLossSubmitResponse 对象
            return gson.fromJson(responseData, ProfitLossSubmitResponse.class);
        }
    }
    // 请求参数类
    @Data
    public static class ProfitLossSubmitVO {
        private Integer market; // 交易市场
        private String ts; // 股票市场
        private String code; // 股票代码
        private String validityTime; // 到期时间，时间戳格式
        private Number profitTriggerPrice; // 止盈触发价格
        private Number profitTrustPrice; // 止盈委托价格
        private Integer profitPriceType; // 止盈委托价格类型
        private Number profitTrustCount; // 止盈委托数量
        private Number lossTriggerPrice; // 止损触发价格
        private Number lossTrustPrice; // 止损委托价格
        private Integer lossPriceType; // 止损委托价格类型
        private Number lossTrustCount; // 止损委托数量

        // Getters and Setters
    }

    // 响应类
    @Data
    public class ProfitLossSubmitResponse {
        private String code; // 错误码
        private String msg;  // 异常描述
        private String id;   // 智能单 ID

        // Getters and Setters
    }

    // ------------------ 止盈止损交易改单 ------------------
    public ProfitLossUpdateResponse updateProfitLossOrder(ProfitLossUpdateVO updateVO, String token) throws IOException {
        Gson gson = new GsonBuilder().create();

        // 创建请求
        Request request = new Request.Builder()
                .url(base + "/trade/intelligent_order/profit_loss/update") // 替换为实际的服务器地址
                .addHeader("token", token)
                .post(RequestBody.create(gson.toJson(updateVO), MediaType.parse("application/json")))
                .build();

        OkHttpClient client = new OkHttpClient();
        // 发送请求并处理响应
        try (Response response = client.newCall(request).execute()) {
            if (!response.isSuccessful()) {
                throw new IOException("Unexpected code " + response);
            }

            // 处理响应
            String responseData = response.body().string();
            System.out.println("Response: " + responseData);

            // 将响应解析为 ProfitLossUpdateResponse 对象
            return gson.fromJson(responseData, ProfitLossUpdateResponse.class);
        }
    }

    // 请求参数类
    @Data
    public static class ProfitLossUpdateVO {
        private String id; // 智能单ID
        private Integer market; // 交易市场
        private String ts; // 股票市场
        private String code; // 股票代码
        private String validityTime; // 到期时间，时间戳格式
        private Number profitTriggerPrice; // 止盈触发价格
        private Number profitTrustCount; // 止盈委托数量
        private Number lossTriggerPrice; // 止损触发价格
        private Integer lossPriceType; // 止损委托价格类型
        private Number lossTrustPrice; // 止损委托价格
        private Integer profitPriceType; // 止盈委托价格类型
        private Number profitTrustPrice; // 止盈委托价格
        private Number lossTrustCount; // 止损委托数量

        // Getters and Setters
    }

    // 响应类
    @Data
    public static class ProfitLossUpdateResponse {
        private String code; // 错误码
        private String msg;  // 异常描述

        // Getters and Setters
    }



}
